home *** CD-ROM | disk | FTP | other *** search
/ Disc to the Future 2 / Disc to the Future Part II Programmer's Reference (Wayzata Technology)(6013)(1992).bin / MAC / MACSHELL / MS1 / COMMANDS / PREFS.C < prev    next >
Text File  |  1992-12-02  |  11KB  |  461 lines
  1. /*
  2.  *    MacShell Source File
  3.  *
  4.  *    Copyright (c) 1989, 1990, 1991, 1992  Suick Bay Technologies.  All rights reserved.
  5.  *
  6.  *
  7.  *    RESTRICTIONS ON MacShell program and source code.
  8.  *
  9.  *    Ñ╩MacShell¬ is a product of Suick Bay Technologies and is provided for
  10.  *    restricted use by the owner of the CDROM "Disk to the future II".
  11.  *
  12.  *    Ñ╩No permission is granted for any commercial use without the written
  13.  *    consent of the Suick Bay Technologies.
  14.  *
  15.  *    Ñ╩No permission is granted for any redistribution of any kind use without
  16.  *    the written consent of the Suick Bay Technologies.
  17.  *
  18.  *    Ñ╩Permission is granted to use this for any personal noncommercial use.
  19.  *
  20.  *    Ñ╩You may not distribute source or executable code at all, nor may you 
  21.  *    distribute it with or within a commercial product without the written
  22.  *    consent of the Suick Bay Technologies.  Please send modifications to 
  23.  *    the author for inclusion in updates to the program.  Thanks.
  24.  *
  25.  *
  26.  *    MacShell¬ IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  27.  *    WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  28.  *    PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  29.  *
  30.  *    SUICK BAY TECHNOLOGIES SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  31.  *    INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY MACSHELL
  32.  *    OR ANY PART THEREOF. 
  33.  *
  34.  *    In no event will Suick Bay Technologies be liable for any lost revenue
  35.  *    or profits or other special, indirect and consequential damages, even if
  36.  *    Suick Bay Technologies has been advised of the possibility of such damages.
  37.  *
  38.  *    Suick Bay Technologies can be reached at:
  39.  *    
  40.  *    8768 Cottonwood lane
  41.  *    Maple Grove, MN 55369
  42.  *    Voice: (612) 425-7025
  43.  *    AppleLink: D5233
  44.  *    
  45.  *
  46.  *    No parts of this software may be reproduced or stored in a
  47.  *    retrieval system or transmitted in any form, or any means,
  48.  *    electronic, mechanical, photocopying, recording or otherwise,
  49.  *    without the prior written permission of Suick Bay Technologies.
  50.  *    
  51.  *    Spread the word and not the disk.
  52.  *    
  53.  *    SPK 012290    :    Initial
  54.  */
  55.  
  56. #include    "SystemPub.h"
  57. #include    "Proc.h"
  58. #include    "ShellPub.h"
  59. #include    "Prefs.h"
  60.  
  61. /*******************************************************************/
  62.  
  63. enum
  64.     {
  65.     PrefOk = 1,
  66.     PrefCancel,
  67.     PrefDefault,
  68.     ProfStartUp = 5,
  69.     ProfNewShell,
  70.     NewItemShell = 9,
  71.     NewItemFile,
  72.     TextFileCrea = 12,
  73.     ShellLimit = 14,
  74.     AdvanScroll,
  75.     MFBackTasks,        /* Not used */
  76.     MacOSPath = 18,
  77.     UNIXPath,
  78.     MSDOSPath,
  79.     MinMem = 21,
  80.     bootScripts,
  81.     caseIns
  82.     }    PrefDLOGItem;
  83.  
  84.  
  85. PrefRec        ShellPrefs;
  86. PrefHand    PrefsH = NULL;
  87.  
  88. /*******************************************************************/
  89.  
  90. DefaultPrefs( PrefPtr pptr )
  91. {
  92. int16        i;
  93.  
  94.     pptr->useProfileStartup        = TRUE;
  95.     pptr->useProfileNewShell    = FALSE;
  96.     pptr->newShellOnItem        = TRUE;
  97.     pptr->useAdvanScroll        = FALSE;
  98.     pptr->useMFBackTasks        = TRUE;
  99.     pptr->TextCreator            = 'sBAY';
  100.     pptr->ShellCharLimit        = 32000;
  101.     pptr->useMinMem                = FALSE;
  102.     pptr->useBootScript            = FALSE;
  103.     pptr->caseIns                = TRUE;
  104.  
  105.     pptr->useMacOSPath             = FALSE;
  106.     pptr->useUNIXPath            = TRUE;
  107.     pptr->useDOSPath            = FALSE;
  108.     
  109.     
  110.     for( i = 0; i < EXTRAINT; i++ )
  111.         pptr->extra[ i ] = 0;
  112. }
  113.  
  114. /*******************************************************************/
  115.  
  116. GetShellPrefs()
  117. {
  118.     PrefsH = (PrefHand) GetResource( PREFTYPE, PREFSID );
  119.     
  120.     if( PrefsH )
  121.         ShellPrefs = **PrefsH;
  122.     else
  123.         DefaultPrefs( &ShellPrefs );
  124. }
  125.  
  126. /*******************************************************************/
  127.  
  128. SavePrefs()
  129. {    
  130.     if( PrefsH )    /* prefs existed as resource before last call */
  131.         {
  132.         **PrefsH = ShellPrefs;
  133.         ChangedResource( PrefsH );
  134.         WriteResource( PrefsH );        
  135.         }
  136.     else            /* make a new resource */
  137.         {
  138.         PrefsH = (PrefHand) New( PrefRec );
  139.         
  140.         if( PrefsH )
  141.             {
  142.             **PrefsH = ShellPrefs;
  143.         
  144.             AddResource( PrefsH, PREFTYPE, PREFSID, NULL );
  145.             WriteResource( PrefsH );        
  146.             }
  147.         }
  148. }
  149.  
  150. /*******************************************************************/
  151.  
  152. SetDLOGPrefs( DialogPtr dPtr, PrefPtr pptr )
  153. {
  154. char    str[ 64 ];
  155.  
  156.     SetCheck( dPtr, ProfStartUp, pptr->useProfileStartup );
  157.     SetCheck( dPtr, ProfNewShell, pptr->useProfileNewShell );
  158.     
  159.     SetCheck( dPtr, NewItemShell, pptr->newShellOnItem );
  160.     SetCheck( dPtr, NewItemFile, !(pptr->newShellOnItem) );
  161.     
  162.     /* TextFileCrea */
  163.     TypeToStr( pptr->TextCreator, str );
  164.     CtoPstr( str );
  165.     SetEText (dPtr, TextFileCrea, str );
  166.     
  167.     /* ShellLimit */
  168.     NumToString( pptr->ShellCharLimit, str );
  169.     SetEText( dPtr, ShellLimit, str );
  170.     
  171.     SetCheck( dPtr, AdvanScroll, pptr->useAdvanScroll );
  172.     SetCheck( dPtr, MFBackTasks, pptr->useMFBackTasks );
  173.     
  174.     SetCheck( dPtr, MacOSPath, pptr->useMacOSPath );
  175.     SetCheck( dPtr, UNIXPath,  pptr->useUNIXPath );
  176.     SetCheck( dPtr, MSDOSPath, pptr->useDOSPath );
  177.     
  178.     SetCheck( dPtr, MinMem, pptr->useMinMem );
  179.     SetCheck( dPtr, bootScripts, pptr->useBootScript );
  180.     SetCheck( dPtr, caseIns, pptr->caseIns );
  181. }
  182.  
  183. /*******************************************************************/
  184.  
  185. Boolean        DoPREFSDialog()
  186. {
  187. DialogPtr     dPtr;
  188. int16        itemHit, check;
  189. PrefRec        TempPrefs;
  190.  
  191.     dPtr = GetNewDialog( PREFSDLOG, NULL, -1L );
  192.     if( dPtr == NULL )
  193.         return;
  194.         
  195.     GetShellPrefs();
  196.     TempPrefs = ShellPrefs;
  197.     
  198.     SetArrow();
  199.     CenterDialog( dPtr );
  200.     OutlineButton( dPtr, 15 );
  201.     SetDLOGPrefs( dPtr, &TempPrefs );
  202.  
  203.     while( 1 )
  204.         {
  205.         ModalDialog( NULL, &itemHit );
  206.         
  207.         switch( itemHit )
  208.             {
  209.             case    PrefDefault    :
  210.                 DefaultPrefs( &TempPrefs );
  211.                 SetDLOGPrefs( dPtr, &TempPrefs );
  212.                 /* DrawDialog( dPtr ); */
  213.                 break;
  214.                 
  215.             case    ProfStartUp    :
  216.                 GetCheck( dPtr, itemHit, &check );
  217.                 SetCheck( dPtr, itemHit, !check );
  218.                 TempPrefs.useProfileStartup = !check;
  219.                 break;
  220.                 
  221.             case    ProfNewShell:
  222.                 GetCheck( dPtr, itemHit, &check );
  223.                 SetCheck( dPtr, itemHit, !check );
  224.                 TempPrefs.useProfileNewShell = !check;
  225.                 break;
  226.                 
  227.             case    NewItemShell:
  228.             case    NewItemFile    :
  229.                 pushradiobutton( dPtr, itemHit, NewItemShell, NewItemFile );
  230.                 GetCheck( dPtr, NewItemShell, &check );
  231.                 TempPrefs.newShellOnItem = check;
  232.                 break;
  233.                 
  234.             case    TextFileCrea:
  235.             case    ShellLimit    :
  236.                 break;
  237.                 
  238.             case    AdvanScroll    :
  239.                 GetCheck( dPtr, itemHit, &check );
  240.                 SetCheck( dPtr, itemHit, !check );
  241.                 TempPrefs.useAdvanScroll = !check;
  242.                 break;
  243.                 
  244.             case    MFBackTasks    :    
  245.                 GetCheck( dPtr, itemHit, &check );
  246.                 SetCheck( dPtr, itemHit, !check );
  247.                 TempPrefs.useMFBackTasks = !check;
  248.                 break;
  249.                 
  250.             case    MinMem    :
  251.                 GetCheck( dPtr, itemHit, &check );
  252.                 SetCheck( dPtr, itemHit, !check );
  253.                 TempPrefs.useMinMem = !check;
  254.                 break;
  255.  
  256.             case    bootScripts    :
  257.                 GetCheck( dPtr, itemHit, &check );
  258.                 SetCheck( dPtr, itemHit, !check );
  259.                 TempPrefs.useBootScript = !check;
  260.                 break;
  261.             
  262.             case    caseIns    :
  263.                 GetCheck( dPtr, itemHit, &check );
  264.                 SetCheck( dPtr, itemHit, !check );
  265.                 TempPrefs.caseIns = !check;
  266.                 break;
  267.             
  268.             case    MacOSPath    :
  269.             case    UNIXPath    :
  270.             case    MSDOSPath    :
  271.                 pushradiobutton( dPtr, itemHit, MacOSPath, MSDOSPath );
  272.                 break;
  273.             }
  274.             
  275.         if( itemHit == PrefOk )
  276.             {
  277.             int32    value;
  278.                 
  279.             if( IsTextLegalInt32( 4096L, 512L*1024L, dPtr, ShellLimit, &value ) )
  280.                 {
  281.                 ShellPrefs.ShellCharLimit = value;    /* save limit */
  282.                 break;
  283.                 }
  284.             else
  285.                 SysBeep( 1 );
  286.             }
  287.  
  288.         if( itemHit == PrefCancel )
  289.             break;
  290.         }
  291.  
  292.     if( itemHit == PrefOk )    /* save prefs, note limit checked/saved above ! */
  293.         {
  294.         char    str[ 32 ];
  295.         
  296.         GetEText( dPtr, TextFileCrea, str );
  297.         PtoCstr( str );
  298.         ShellPrefs.TextCreator = StrToType( str );
  299.  
  300.         GetCheck( dPtr, ProfStartUp, &check );
  301.         ShellPrefs.useProfileStartup = check;
  302.         
  303.         GetCheck( dPtr, ProfNewShell, &check );
  304.         ShellPrefs.useProfileNewShell = check;
  305.  
  306.         GetCheck( dPtr, NewItemShell, &check );
  307.         ShellPrefs.newShellOnItem = check;
  308.  
  309.         GetCheck( dPtr, AdvanScroll, &check );
  310.         ShellPrefs.useAdvanScroll = check;
  311.  
  312.         GetCheck( dPtr, MFBackTasks, &check );
  313.         ShellPrefs.useMFBackTasks = check;
  314.         
  315.         GetCheck( dPtr, MinMem, &check );
  316.         ShellPrefs.useMinMem = check;
  317.         
  318.         GetCheck( dPtr, bootScripts, &check );
  319.         ShellPrefs.useBootScript = check;
  320.         
  321.         GetCheck( dPtr, caseIns, &check );
  322.         ShellPrefs.caseIns = check;
  323.  
  324.         GetCheck( dPtr, MacOSPath, &check );
  325.         ShellPrefs.useMacOSPath = check;
  326.  
  327.         GetCheck( dPtr, UNIXPath, &check );
  328.         ShellPrefs.useUNIXPath = check;
  329.  
  330.         GetCheck( dPtr, MSDOSPath, &check );
  331.         ShellPrefs.useDOSPath = check;
  332.  
  333.         SavePrefs();
  334.         }
  335.  
  336.     DisposDialog( dPtr );
  337. }
  338.  
  339. /*******************************************************************/
  340.  
  341. Boolean            DoPREFS( int16 ProcToken, WHandle ShellWh, int16 ProcID,
  342.                     char *string )
  343. {
  344. int16                i, argc;
  345. char            *cp, argument[ 256 ];
  346. ShellWindRec    **MyShell = (ShellWindRec **) (**ShellWh).thing;
  347.  
  348.     switch( ProcToken )
  349.         {
  350.         case    PROC_INIT    :
  351.             (**MyShell).Proc[ ProcID ].flags = TRUE;
  352.             break;
  353.             
  354.         case    PROC_TERM    :
  355.         case    PROC_BREAK    :
  356.             /* Tell the shell that we're done */
  357.             SendOutToken( ShellWh, ProcID, PROC_BREAK );
  358.             /* Turn ourself off */
  359.             (**MyShell).Proc[ ProcID ].ProcActive = FALSE;
  360.             break;
  361.             
  362.         case    PROC_STDIN    :
  363.             if( (**MyShell).Proc[ ProcID ].flags )
  364.                 {
  365.                 (**MyShell).Proc[ ProcID ].flags = FALSE;        
  366.  
  367.                 /* get arguments */
  368.                 argc = (**MyShell).Proc[ ProcID ].argc;
  369.                 
  370.                 if( argc > 1 )
  371.                     {
  372.                     for( i = 1; i < argc; i++ )
  373.                         {
  374.                         GetArgv( ShellWh, ProcID, i, argument );
  375.                         cp = argument;
  376.             
  377.                         if( *cp++ == '-' )
  378.                             while( *cp )
  379.                                 {
  380.                                 switch( *cp )
  381.                                     {
  382.                                     case    'A'    :    /* use advanced scroll bars */
  383.                                     case    'a'    :    /* use advanced scroll bars */
  384.                                         ShellPrefs.useAdvanScroll = (*cp == 'A');
  385.                                         break;
  386.                                         
  387.                                     case    'c'    :        /* Creator */
  388.                                         i++;
  389.                                         if( i < argc )
  390.                                             {
  391.                                             char    temp[ 256 ];
  392.                                             GetArgv( ShellWh, ProcID, i, temp );
  393.                                             ShellPrefs.TextCreator = StrToType( temp );
  394.                                             }
  395.                                         break;
  396.                                         
  397.                                     case    's'    :    /* 'New' menu item opens shell */
  398.                                     case    'f'    :    /* 'New' menu item opens empty file. */
  399.                                         ShellPrefs.newShellOnItem = (*cp == 's');
  400.                                         break;
  401.  
  402.                                     case    'T'    :    /* enter key executes commands */
  403.                                     case    't'    :
  404.                                         ShellPrefs.useMFBackTasks = (*cp == 'T');
  405.                                         break;
  406.                                         
  407.                                     case    'P'    :    /* use '.profile' on startup */
  408.                                     case    'p'    :
  409.                                         ShellPrefs.useProfileStartup = (*cp == 'P');
  410.                                         break;
  411.  
  412.                                     case    'I'    :    /* case Insensitive */
  413.                                     case    'i'    :
  414.                                         ShellPrefs.caseIns = (*cp == 'I');
  415.                                         break;
  416.                                         
  417.                                     case    'N'    :    /* use '.profile' on newly openned shells */
  418.                                     case    'n'    :
  419.                                         ShellPrefs.useProfileNewShell = (*cp == 'N');
  420.                                         break;
  421.                                         
  422.                                     case    'l'    :    /* set character limit on open shells */
  423.                                         i++;
  424.                                         if( i < argc )
  425.                                             {
  426.                                             char    temp[ 256 ];
  427.                                             int32    value;
  428.                                             
  429.                                             GetArgv( ShellWh, ProcID, i, temp );
  430.                                             CtoPstr( temp );
  431.                                             StringToNum( temp, &value );
  432.                                             ShellPrefs.ShellCharLimit = value;
  433.                                             }
  434.                                         break;
  435.                                         
  436.                                     case    'M'    :    /* Mac OS path */
  437.                                     case    'U'    :    /* UNIX path */
  438.                                     case    'D'    :    /* MSDOS path */
  439.                                         ShellPrefs.useMacOSPath = (*cp == 'M');
  440.                                         ShellPrefs.useUNIXPath     = (*cp == 'U');
  441.                                         ShellPrefs.useDOSPath     = (*cp == 'D');
  442.                                         break;
  443.                                     }
  444.                                 cp++;
  445.                                 }
  446.                         }
  447.                         
  448.                     SavePrefs();
  449.                     }
  450.                 else
  451.                     DoPREFSDialog();
  452.  
  453.                 /* Tell the shell that we're done */
  454.                 SendOutToken(  ShellWh, ProcID, PROC_BREAK );
  455.                 
  456.                 /* Turn ourself off */
  457.                 (**MyShell).Proc[ ProcID ].ProcActive = FALSE;
  458.                 return( FALSE );
  459.                 }
  460.         }
  461. }